package com.abc.structure.binarySearchTree;

import com.abc.structure.binarySearchTree.printer.BinaryTreeInfo;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 二叉搜索树
 */
public class BinarySearchTree<E> implements BinaryTreeInfo {

    private int size;

    private Node<E> root;

    private Comparator<E> comparator;

    public BinarySearchTree() {
        this(null);
    }

    public BinarySearchTree(Comparator<E> comparator) {
        this.comparator = comparator;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void clear() {
        root = null;
        size = 0;
    }

    /**
     * 添加步骤：
     * 找到父节点 parent
     * 创建新节点 node
     * 比较 得出 parent.left = node 或 parent.right = node
     */
    public void add(E element) {
        elementNotNullCheck(element);

        if (root == null) {
            root = new Node<E>(element, null);
            size++;
            return;
        }

        Node<E> parent = root; // 记录最后插入节点的parent节点
        Node<E> node = root; // 遍历的当前节点
        int cmp = 0; // 记录最后要插入左边还是右边
        while (node != null) {
            cmp = compare(element, node.element);
            parent = node;
            if (cmp > 0) {
                node = node.right;
            } else if (cmp < 0) {
                node = node.left;
            } else { // 相等
                node.element = element;
                return;
            }
        }

        Node<E> newNode = new Node<E>(element, parent);
        if (cmp > 0) {
            parent.right = newNode;
        } else { // 小于 0 的情况
            parent.left = newNode;
        }
        size++;
    }

    /**
     * 删除元素 element
     */
    public void remove(E element) {
        remove(node(element));
    }

    public boolean contains(E element) {
        return node(element) != null;
    }

    /**
     * 查询元素 element 是否存在
     *
     * @return
     */
    private Node<E> node(E element) {
        Node<E> node = root;
        while (node != null) {
            int cmp = compare(element, node.element);
            if (cmp == 0) {
                return node;
            } else if (cmp > 0) {
                node = node.right;
            } else {
                node = node.left;
            }
        }
        return node;
    }

    private void remove(Node<E> node) {
        if (node == null) return;

        if (node.hasTwoChildren()) {
            Node<E> s = successor(node);
            // 用后继节点覆盖
            node.element = s.element;
            node = s;
        }

        // 删除 node 节点(node 的度必然是 1 或者是 0)
        Node<E> replacement = node.left != null ? node.left : node.right;
        if (replacement != null) {
            // 更改 parent
            replacement.parent = node.parent;
            if (node.parent == null) { // node 是度为 1 的根节点
                root = replacement;
            } else if (node == node.parent.left) {
                node.parent.left = replacement;
            } else {
                node.parent.right = replacement;
            }

        } else if (node.parent == null) { //node 是叶子节点而且是根节点
            root = null;
        } else { // node 是叶子节点，但不是根节点
            if (node == node.parent.left) {
                node.parent.left = null;
            } else {
                node.parent.right = null;
            }
        }
        size--;
    }

    /**
     * 查找 node 的前驱节点
     * 1. 如果 node.left != null:
     * prodecessor = node.left.right.right.....
     * 终止条件: node.right == null
     * 2. 如果 node.left == null && node.parent != null
     * prodecessor = node.parent.parent......
     * 终止条件: node.parent 在 node 的右节点树中
     * 3. 如果 node.left == null && node.parent == null
     * 只有一种情况，这个 node 节点是根节点，没有前驱节点
     */
    private Node<E> predecessor(Node<E> node) {
        if (node == null) return null;
        Node<E> p = node.left;
        if (p != null) {
            // node.left != null 的时候，从 node.left.right.right... 节点中找
            // 从 node.left 的 right 节点找
            while (p.right != null) {
                p = p.right;
            }
            return p;
        }

        // 如果 node.left == null && node.parent != null, 那么一直从node.parent.parent找
        // 从父节点，祖父节点中找
        while (node.parent != null && node == node.parent.left) {
            node = node.parent;
        }

        // node.parent == null
        // node == node.parent.right
        return node.parent;
    }

    /**
     * 查找 node 的后驱节点
     */
    private Node<E> successor(Node<E> node) {
        if (node == null) return null;

        Node<E> s = node.right;
        if (s != null) {
            // node.right != null
            // 从 node.right 的左子树中找
            while (s.left != null) {
                s = s.left;
            }
            return s;
        }

        // node.right == null && node.parent != null
        // 从 父节点，祖父节点中找
        while (node.parent != null && node == node.parent.right) {
            node = node.parent;
        }

        return node.parent;
    }

    /**
     * 返回值等于 0 ， 相等
     * 返回值大于 0 ， 代表 e1 大于 e2
     * 返回值小于 0 ， 代表 e1 小于 e2
     *
     * @return
     */
    private int compare(E e1, E e2) {
        if (comparator != null) {
            return comparator.compare(e1, e2);
        }
        return ((Comparable<E>) e1).compareTo(e2);
    }


    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("Element can not be Null.");
        }
    }

    @Override
    public Object root() {
        return root;
    }

    @Override
    public Object left(Object node) {
        return ((Node<E>) node).left;
    }

    @Override
    public Object right(Object node) {
        return ((Node<E>) node).right;
    }

    @Override
    public Object string(Object node) {
        Node<E> n = (Node<E>) node;
        String parentStr = "null";
        if (n.parent != null) {
            parentStr = n.parent.element.toString();
        }
        return n.element + "_p(" + parentStr + ")";
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public Node<E> getRoot() {
        return root;
    }

    public void setRoot(Node<E> root) {
        this.root = root;
    }

    private static class Node<E> {
        E element;
        Node<E> parent;
        Node<E> left;
        Node<E> right;

        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        public boolean isLeaf() {
            return left == null && right == null;
        }

        public boolean hasTwoChildren() {
            return left != null && right != null;
        }}

    public static abstract class Visitor<E> {

        boolean stop = false;

        abstract void visit(E element);

    }

    /**
     * 前序遍历
     * 先根节点，再左子树，再右子树
     */
    public void preorder(Visitor<E> visitor) {
        if (visitor == null) return;
        preorder(root, visitor);
    }

    /**
     * 中序遍历
     * 先左子树，再根节点，最后右子树
     */
    public void inorder(Visitor<E> visitor) {
        if (visitor == null) return;
        inorder(root, visitor);
    }

    /**
     * 后序遍历
     * 先左子树， 再右子树，最后根节点
     */
    public void postorder(Visitor<E> visitor) {
        if (visitor == null) return;
        postorder(root, visitor);
    }

    /**
     * 层级遍历
     * 使用队列实现:
     * 1. 将根节点放入队列
     * 2. 遍历以下操作，直到队列为空:
     * - 取出队列的头部 A 节点
     * - 将 A 的左节点放入队列
     * - 将 A 的右节点放入队列
     */
    public void levelOrder(Visitor<E> visitor) {
        if (root == null || visitor == null) return;

        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            if (visitor.stop) return;
            visitor.visit(node.element);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

    /**
     * 判断该树是否为完全二叉树
     * 如果树不为空，开始层序遍历二叉树(用队列)
     * 如果 node.left != null, 将 node.left 入队
     * 如果 node.left == null && node.right != null, 返回 false
     * 如果 node.right != null, 将 node.right 入队
     * 如果 node.right == null,
     * 那么 后面遍历的节点都应该为叶子节点，才是完全二叉树
     * 否则返回 false
     */
    public boolean isComplete() {
        if (root == null) return false;

        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);

        boolean leaf = false;

        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            if (leaf && !node.isLeaf()) return false;// 如果要叶子节点，但是该节点又不是，那么就return false
            if (node.left != null) {
                queue.offer(node.left);
            } else if (node.right != null) { // node.left == null && node.right != null
                return false;
            }
            if (node.right != null) {
                queue.offer(node.right);
            } else {
                leaf = true;
            }
        }
        return true;
    }

    /**
     * 树的高度
     * 使用层序遍历实现
     * 一层一层遍历，遍历完一层，高度就增加 1
     */
    public Integer height() {
        if (root == null) return 0;
        int height = 0;
        int levelSize = 1;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            levelSize--;
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
            if (levelSize == 0) {
                levelSize = queue.size();
                height++;
            }
        }
        return height;
    }

    /**
     * 树的高度
     * 使用递归实现
     */
    public Integer height2() {
        return height(root);
    }

    private Integer height(Node<E> node) {
        if (node == null) return 0;
        return 1 + Math.max(height(node.left), height(node.right));
    }

    private void postorder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;
        postorder(node.left, visitor);
        postorder(node.right, visitor);
        if (visitor.stop) return;
        visitor.visit(node.element);
    }

    private void inorder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;
        inorder(node.left, visitor);
        if (visitor.stop) return;
        visitor.visit(node.element);
        inorder(node.right, visitor);
    }

    private void preorder(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;

        visitor.visit(node.element);
        preorder(node.left, visitor);
        preorder(node.right, visitor);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        toString(root, sb, "");
        return sb.toString();
    }

    private void toString(Node<E> node, StringBuilder sb, String prefix) {
        if (node == null) return;

        sb.append(prefix).append(node.element).append("\n");
        toString(node.left, sb, prefix + "[L]");
        toString(node.right, sb, prefix + "[R]");
    }

    //    /**
//     * 前序遍历
//     * 先根节点，再左子树，再右子树
//     */
//    public void preorderTraversal() {
//        preorderTraversal(root);
//    }
//
//    /**
//     * 中序遍历
//     * 先左子树，再根节点，最后右子树
//     */
//    public void inorderTraversal() {
//        inorderTraversal(root);
//    }
//
//    /**
//     * 后续遍历
//     * 先左子树，再右子树，最后根节点
//     */
//    public void postorderTraversal() {
//        postorderTraversal(root);
//    }

//    /**
//     * 层级遍历
//     * 从上到下，从左到右依次访问每一个节点
//     *
//     * 实现思路: 使用队列
//     * 1. 将根节点入队
//     * 2. 循环执行以下操作，直到队列为空
//     *  - 将对头节点 A 出队， 进行访问
//     *  - 将 A 的左子节点入队
//     *  - 将 A 的右子节点入队
//     */
//    public void levelOrderTraversal() {
//        if (root == null) return;
//
//        Queue<Node<E>> queue = new LinkedList<>();
//        queue.offer(root);
//        while (!queue.isEmpty()) {
//            Node<E> currentNode = queue.poll();
//            System.out.println(currentNode.element);
//            if (currentNode.left != null) {
//                queue.offer(currentNode.left);
//            }
//            if (currentNode.right != null) {
//                queue.offer(currentNode.right);
//            }
//        }
//    }

//    private void postorderTraversal(Node<E> node) {
//        if (node == null) return;
//        postorderTraversal(node.left);
//        postorderTraversal(node.right);
//        System.out.println(node.element);
//    }
//
//    private void inorderTraversal(Node<E> node) {
//        if (node == null) return;
//        inorderTraversal(node.left);
//        System.out.println(node.element);
//        inorderTraversal(node.right);
//    }
//
//    private void preorderTraversal(Node<E> node) {
//        // 先根节点，再左子树，再右子树
//        if (node == null) return;
//        System.out.println(node.element);
//        preorderTraversal(node.left);
//        preorderTraversal(node.right);
//    }


}
